home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / a_utils / expanded.lha / test_suite / testgeob.C < prev    next >
C/C++ Source or Header  |  1992-03-19  |  16KB  |  722 lines
  1. //
  2. // Linear-Affine-Projective Geometry Package
  3. //
  4. // testgeob.C
  5. //
  6. // $Header$
  7. //
  8. // William J.R. Longabaugh 
  9. // University of Washington
  10. //
  11. // Test programs for the linear-affine-projective geometry
  12. // package described in William J.R. Longabaugh, "An Expanded
  13. // System for Coordinate-Free Geometric Programming", Master's 
  14. // thesis, University of Washington, 1992.
  15. //
  16. // Copyright (c) 1992, William J.R. Longabaugh
  17. //   Copying, use and development for non-commercial purposes permitted.
  18. //   All rights for commercial use reserved.
  19. //   This software is unsupported and without warranty; it is
  20. //   provided "as is".
  21. //
  22. // ***********************************************************************
  23.  
  24. #include "Lap.h"
  25. #include <math.h>
  26.  
  27. extern void test1(void);
  28. extern void test2(void);
  29. extern void test3(void);
  30. extern void test4(void);
  31. extern void test5(void);
  32. extern void test6(void);
  33. extern void test7(void);
  34.  
  35. // ***********************************************************************
  36.  
  37. int main(void)
  38. {
  39.   test1();
  40.   test2();
  41.   test3();
  42.   test4();
  43.   test5();
  44.   test6();
  45.   test7();
  46.   return (0);
  47. }
  48.  
  49.  
  50. // ***********************************************************************
  51. // Test the casting of maps and multimaps to geobs:
  52.  
  53. void test1(void)
  54. {
  55.   cout << "ENTERING TEST1\n";
  56.   VSpace v("Test vector space", 3, TRUE);
  57.   ASpace a("Test affine space", 2, TRUE);
  58.   PSpace p("Test projective space", v, a);
  59.  
  60. // Create a first order map and convert it to a Multimap:
  61.  
  62.   Frame fra = a.StdBasis();
  63.   APoint a1(fra, ScalarList(3.6, -4.5, 1.0));
  64.   APoint a2(fra, ScalarList(2.2, 5.1, 1.0));
  65.   APoint a3(fra, ScalarList(-6.7, 2.3, 1.0));
  66.  
  67.   Simplex s1("test simplex", a, GeObList(a1, a2, a3));
  68.   AffineMap am(a.StdSimplex(), s1);
  69.   cout << am;
  70.   MAM multi(am);
  71.   cout << multi;
  72.  
  73.   MAM noargp;
  74.   noargp = multi(GeObList(fra[2]));
  75.   APoint tst(noargp);
  76.   cout << tst;
  77.  
  78.   MAM noargv;
  79.   noargv = multi(GeObList(fra[0]));
  80.   AVector tstv(noargv);
  81.   cout << tstv;
  82.  
  83. // Create a MLM linear functional and convert it to a dual vector
  84.  
  85.   Vector v1(v.StdBasis(), ScalarList(4.5, 6.2, 3.6));
  86.   Vector vd = v1.Dual();
  87.   MLM multilf(vd);
  88.  
  89.   Vector vdn(multilf);
  90.   cout << vdn;
  91.  
  92. // Convert a Linear Map functional into a dual vector:
  93.  
  94.   LinearMap lm(vd);
  95.   Vector vdn2(lm);
  96.   cout << vdn2;
  97. }
  98.  
  99. // ***********************************************************************
  100. // Tests of auto scalars
  101.  
  102. void test2(void)
  103. {
  104.   cout << "ENTERING TEST2\n";
  105.  
  106.   GeOb myreal(4.6);
  107.   cout << myreal;
  108.   Scalar foo = myreal.ToScalar();
  109.   cout << foo << "\n";
  110. }
  111.  
  112. // ***********************************************************************
  113. // Tests of tuple creation, referencing, and setting
  114.  
  115. void test3(void)
  116. {
  117.   cout << "ENTERING TEST3\n";
  118.   VSpace v("Test vector space", 3, TRUE);
  119.   ASpace a("Test affine space", TRUE, v);
  120.   VSpace t = a.GetSpace(TANGENT);
  121.  
  122.   VSpace cv1("Cartesian vspace1", SpaceList(v, v, v), FALSE);
  123.   VSpace cv2("Cartesian vspace1", SpaceList(v, t), FALSE);
  124.   ASpace ca1("Cartesian aspace1", SpaceList(a, a, a), FALSE);
  125.   VSpace ct1 = ca1.GetSpace(TANGENT);
  126.  
  127.   Frame fra = a.StdBasis();
  128.   APoint a1(fra, ScalarList(3.6, -4.5, 1.0));
  129.   APoint a2(fra, ScalarList(2.5, 7.8, 1.0));
  130.   APoint a3(fra, ScalarList(-1.1, 6.3, 1.0));
  131.   AVector av1 = a2 - a3;
  132.  
  133.   Basis bas = v.StdBasis();
  134.   Vector v1(bas, ScalarList(2.1, 5.4, 8.9));
  135.   Vector v2(bas, ScalarList(7.8, 3.5, 1.1));
  136.   Vector v3(bas, ScalarList(-1.1, 6.3, -2.8));
  137.  
  138. // Create tuples:
  139.  
  140.   Vector vt(cv1, GeObList(av1, v2, a3));
  141.   Vector vt2(cv2, GeObList(v2, av1));
  142.   APoint pt(ca1, GeObList(a1 + av1, (a2 + a3) / 2.0, a3));
  143.   APoint pt2(ca1, GeObList(a1, a2, a3));
  144.   AVector avt(ct1, GeObList(av1, a1 - a2, a3 -a1));
  145.  
  146. // Reference elements:
  147.  
  148.   PPoint vtpp = VectorEC(vt);
  149.  
  150.   GeOb tst1 = avt[0];
  151.   cout << tst1;
  152.   tst1 = avt[2];
  153.   cout << tst1;
  154.   GeOb tst2 = vt2[1];
  155.   cout << tst2;
  156.  
  157.   tst2 = vtpp[0];  // Note autocasting
  158.   cout << tst2;
  159.   tst2 = vt[2];
  160.   cout << tst2;
  161.  
  162.   GeOb tst3 = pt[0];
  163.   cout << tst3;
  164.   tst3 = pt[2];
  165.   cout << tst3;
  166.  
  167.   GeObList tst4 = vtpp.TupleElements();
  168.   cout << tst4;
  169.  
  170. // Modify elements:
  171.  
  172.   tst1 = avt.SetTupleElement(0, a2 - a1);
  173.   cout << tst1;
  174.   tst1 = avt.SetTupleElement(2, av1);
  175.   cout << tst1;
  176.   tst2 = vt2.SetTupleElement(1, a1 - a1);
  177.   cout << tst2;
  178.  
  179.   tst2 = vtpp.SetTupleElement(0, v2);  // Note autocasting
  180.   cout << tst2;
  181.   tst2 = vt.SetTupleElement(2, a2);
  182.   cout << tst2;
  183.  
  184.   tst3 = pt.SetTupleElement(0, a3);
  185.   cout << tst3;
  186.   tst3 = pt.SetTupleElement(2, a3 + av1);
  187.   cout << tst3;
  188. }
  189.  
  190. // ***********************************************************************
  191. // Algebraic operations:
  192.  
  193. void test4(void)
  194. {
  195.   cout << "ENTERING TEST4\n";
  196.   VSpace v("Test vector space", 3, TRUE);
  197.   ASpace a("Test affine space", 2, TRUE);
  198.   PSpace p("Test projective space", v, a);
  199.  
  200.   Frame fra = a.StdBasis();
  201.   APoint a1(fra, ScalarList(3.6, -4.5, 1.0));
  202.   APoint a2(fra, ScalarList(2.5, 7.8, 1.0));
  203.   APoint a3(fra, ScalarList(-3.4, 2.8, 1.0));
  204.   AVector av1 = a2 - a3;
  205.   AVector av2 = a3 - a1;
  206.   AVectorEC avec1(av1);
  207.   AVectorEC avec2(av2);
  208.  
  209.   Basis bas = v.StdBasis();
  210.   Vector v1(bas, ScalarList(2.1, 5.4, 8.9));
  211.   Vector v2(bas, ScalarList(7.8, 3.5, 1.1));
  212.   VectorEC vec1(v1);
  213.   VectorEC vec2(v2);
  214.  
  215.   PPoint pp1(a1);
  216.  
  217. // Add, subtract two vectors, 2 affine vectors, affine/avec combinations,
  218. // general combinations:
  219.  
  220.   GeOb ret = v1 + v2;
  221.   cout << ret;
  222.   ret = v1 - v2;
  223.   cout << ret;
  224.  
  225.   ret = av1 + av2;
  226.   cout << ret;
  227.   ret = av1 - av2;
  228.   cout << ret;
  229.  
  230.   ret = avec1 + avec2;
  231.   cout << ret;
  232.   ret = avec1 - avec2;
  233.   cout << ret;
  234.  
  235.   ret = avec1 + av2;
  236.   cout << ret;
  237.   ret = av1 - avec2;
  238.   cout << ret;
  239.  
  240.   ret = pp1 + a2;
  241.   cout << ret;
  242.   ret = a2 - pp1;
  243.   cout << ret;
  244.  
  245.   ret = vec1 + a2;
  246.   cout << ret;
  247.   ret = a1 - av1;
  248.   cout << ret;
  249.  
  250. // Multiplication and division:
  251.  
  252.   Vector val(4.0);
  253.  
  254.   ret = val * av1;
  255.   cout << ret;
  256.   ret = avec1 * val;
  257.   cout << ret;
  258.   ret = a1 * val;
  259.   cout << ret;
  260.  
  261.   ret = av1 / val;
  262.   cout << ret;
  263.   ret = avec1 / val;
  264.   cout << ret;
  265.   ret = a1 / val;
  266.   cout << ret;
  267. }
  268.  
  269. // ***********************************************************************
  270. // Duals and application:
  271.  
  272. void test5(void)
  273. {
  274.   cout << "ENTERING TEST5\n";
  275.   VSpace v("Test vector space", 3, TRUE);
  276.   ASpace a("Test affine space", 2, TRUE);
  277.   PSpace p("Test projective space", v, a);
  278.  
  279.   Frame fra = a.StdBasis();
  280.   APoint a1(fra, ScalarList(3.6, -4.5, 1.0));
  281.   APoint a2(fra, ScalarList(2.5, 7.8, 1.0));
  282.   APoint a3(fra, ScalarList(-3.4, 2.8, 1.0));
  283.   AVector av1 = a2 - a3;
  284.   AVector av2 = a3 - a1;
  285.   AVectorEC avec1(av1);
  286.   AVectorEC avec2(av2);
  287.  
  288.   Basis bas = v.StdBasis();
  289.   Vector v1(bas, ScalarList(2.1, 5.4, 8.9));
  290.   Vector v2(bas, ScalarList(7.8, 3.5, 1.1));
  291.   Vector v3 = av1;
  292.   VectorEC vec1(v1);
  293.   VectorEC vec2(v2);
  294.  
  295.   PPoint pp1(a1);
  296.  
  297.   GeOb ret1 = v1.Dual();
  298.   cout << ret1;
  299.   GeOb ret2 = av1.Dual();
  300.   cout << ret2;
  301.   GeOb ret3 = avec1.Dual();
  302.   cout << ret3;
  303.   GeOb ret4 = a2.Dual();
  304.   cout << ret4;
  305.   GeOb ret5 = pp1.Dual();
  306.   cout << ret5;
  307.  
  308.   VectorEC vec3(ret2);
  309.  
  310.   Scalar val;
  311.   val = ret1.Apply(v2);
  312.   cout << val << "\n";
  313.   val = av2.Apply(ret2);
  314.   cout << val << "\n";
  315.   val = ret2.Apply(v3);
  316.   cout << val << "\n";
  317.   val = ret1.Apply(a1);
  318.   cout << val << "\n";
  319.   val = avec1.Apply(ret2);
  320.   cout << val << "\n";
  321.   val = pp1.Apply(ret1);
  322.   cout << val << "\n";
  323.   val = vec3.Apply(av1);
  324.   cout << val << "\n";
  325.   val = av2.Apply(vec3);
  326.   cout << val << "\n";
  327. }
  328.  
  329. // ***********************************************************************
  330. // Various mappings:
  331.  
  332. void test6(void)
  333. {
  334.   cout << "ENTERING TEST6\n";
  335.   VSpace v("Test vector space", 3, TRUE);
  336.   ASpace a("Test affine space", 2, TRUE);
  337.   PSpace p("Test projective space", v, a);
  338.  
  339.   Frame fra = a.StdBasis();
  340.   APoint a1(fra, ScalarList(3.6, -4.5, 1.0));
  341.   AVector av1(fra, ScalarList(4.5, 2.1, 0.0));
  342.   AVectorEC avec1(av1);
  343.   Vector v1(a1);
  344.   Vector v2(av1);
  345.   VectorEC vec1(v1);
  346.   VectorEC vec2(v2);
  347.   PPoint pp1(a1);
  348.   HFrame hfra = p.StdBasis();
  349.   PPoint pp2(avec1);
  350.  
  351.   GeOb ret;
  352.  
  353. // APOINT
  354.  
  355.   if (a1.CanMapTo(AFF_POINT)) {
  356.     ret = a1.MapTo(AFF_POINT);
  357.     cout << ret;
  358.   } else {
  359.     cout << "Cannot Map\n";
  360.   } 
  361.   if (a1.CanMapTo(AFF_VECTOR)) { 
  362.     ret = a1.MapTo(AFF_VECTOR);
  363.     cout << ret;
  364.   } else {
  365.     cout << "Cannot Map\n";
  366.   } 
  367.   if (a1.CanMapTo(AFF_VEC_EC)) {
  368.     ret = a1.MapTo(AFF_VEC_EC);
  369.     cout << ret;
  370.   } else {
  371.     cout << "Cannot Map\n";
  372.   } 
  373.   if (a1.CanMapTo(VECTOR)) {
  374.     ret = a1.MapTo(VECTOR);
  375.     cout << ret;
  376.   } else {
  377.     cout << "Cannot Map\n";
  378.   } 
  379.   if (a1.CanMapTo(VEC_EC)) {
  380.     ret = a1.MapTo(VEC_EC);
  381.     cout << ret;
  382.   } else {
  383.     cout << "Cannot Map\n";
  384.   } 
  385.   if (a1.CanMapTo(PROJ_POINT)) {
  386.     ret = a1.MapTo(PROJ_POINT);
  387.     cout << ret;
  388.   } else {
  389.     cout << "Cannot Map\n";
  390.   } 
  391.  
  392. // AVECTOR
  393.  
  394.   if (av1.CanMapTo(AFF_POINT)) {
  395.     ret = av1.MapTo(AFF_POINT);
  396.     cout << ret;
  397.   } else {
  398.     cout << "Cannot Map\n";
  399.   } 
  400.   if (av1.CanMapTo(AFF_VECTOR)) { 
  401.     ret = av1.MapTo(AFF_VECTOR);
  402.     cout << ret;
  403.   } else {
  404.     cout << "Cannot Map\n";
  405.   } 
  406.   if (av1.CanMapTo(AFF_VEC_EC)) {
  407.     ret = av1.MapTo(AFF_VEC_EC);
  408.     cout << ret;
  409.   } else {
  410.     cout << "Cannot Map\n";
  411.   } 
  412.   if (av1.CanMapTo(VECTOR)) {
  413.     ret = av1.MapTo(VECTOR);
  414.     cout << ret;
  415.   } else {
  416.     cout << "Cannot Map\n";
  417.   } 
  418.   if (av1.CanMapTo(VEC_EC)) {
  419.     ret = av1.MapTo(VEC_EC);
  420.     cout << ret;
  421.   } else {
  422.     cout << "Cannot Map\n";
  423.   } 
  424.   if (av1.CanMapTo(PROJ_POINT)) {
  425.     ret = av1.MapTo(PROJ_POINT);
  426.     cout << ret;
  427.   } else {
  428.     cout << "Cannot Map\n";
  429.   } 
  430.  
  431. // AVECTOREC
  432.   if (avec1.CanMapTo(AFF_POINT)) {
  433.     ret = avec1.MapTo(AFF_POINT);
  434.     cout << ret;
  435.   } else {
  436.     cout << "Cannot Map\n";
  437.   } 
  438.   if (avec1.CanMapTo(AFF_VECTOR)) { 
  439.     ret = avec1.MapTo(AFF_VECTOR);
  440.     cout << ret;
  441.   } else {
  442.     cout << "Cannot Map\n";
  443.   } 
  444.   if (avec1.CanMapTo(AFF_VEC_EC)) {
  445.     ret = avec1.MapTo(AFF_VEC_EC);
  446.     cout << ret;
  447.   } else {
  448.     cout << "Cannot Map\n";
  449.   } 
  450.   if (avec1.CanMapTo(VECTOR)) {
  451.     ret = avec1.MapTo(VECTOR);
  452.     cout << ret;
  453.   } else {
  454.     cout << "Cannot Map\n";
  455.   } 
  456.   if (avec1.CanMapTo(VEC_EC)) {
  457.     ret = avec1.MapTo(VEC_EC);
  458.     cout << ret;
  459.   } else {
  460.     cout << "Cannot Map\n";
  461.   } 
  462.   if (avec1.CanMapTo(PROJ_POINT)) {
  463.     ret = avec1.MapTo(PROJ_POINT);
  464.     cout << ret;
  465.   } else {
  466.     cout << "Cannot Map\n";
  467.   } 
  468.  
  469. // VECTOR
  470.  
  471.   if (v1.CanMapTo(AFF_POINT)) {
  472.     ret = v1.MapTo(AFF_POINT);
  473.     cout << ret;
  474.   } else {
  475.     cout << "Cannot Map\n";
  476.   } 
  477.   if (v2.CanMapTo(AFF_POINT)) {
  478.     ret = v2.MapTo(AFF_POINT);
  479.     cout << ret;
  480.   } else {
  481.     cout << "Cannot Map\n";
  482.   } 
  483.   if (v1.CanMapTo(AFF_VECTOR)) { 
  484.     ret = v1.MapTo(AFF_VECTOR);
  485.     cout << ret;
  486.   } else {
  487.     cout << "Cannot Map\n";
  488.   } 
  489.   if (v2.CanMapTo(AFF_VECTOR)) { 
  490.     ret = v2.MapTo(AFF_VECTOR);
  491.     cout << ret;
  492.   } else {
  493.     cout << "Cannot Map\n";
  494.   } 
  495.   if (v1.CanMapTo(AFF_VEC_EC)) {
  496.     ret = v1.MapTo(AFF_VEC_EC);
  497.     cout << ret;
  498.   } else {
  499.     cout << "Cannot Map\n";
  500.   } 
  501.   if (v2.CanMapTo(AFF_VEC_EC)) {
  502.     ret = v2.MapTo(AFF_VEC_EC);
  503.     cout << ret;
  504.   } else {
  505.     cout << "Cannot Map\n";
  506.   } 
  507.   if (v1.CanMapTo(VECTOR)) {
  508.     ret = v1.MapTo(VECTOR);
  509.     cout << ret;
  510.   } else {
  511.     cout << "Cannot Map\n";
  512.   } 
  513.   if (v1.CanMapTo(VEC_EC)) {
  514.     ret = v1.MapTo(VEC_EC);
  515.     cout << ret;
  516.   } else {
  517.     cout << "Cannot Map\n";
  518.   } 
  519.   if (v1.CanMapTo(PROJ_POINT)) {
  520.     ret = v1.MapTo(PROJ_POINT);
  521.     cout << ret;
  522.   } else {
  523.     cout << "Cannot Map\n";
  524.   } 
  525.   if (v2.CanMapTo(PROJ_POINT)) {
  526.     ret = v2.MapTo(PROJ_POINT);
  527.     cout << ret;
  528.   } else {
  529.     cout << "Cannot Map\n";
  530.   } 
  531.  
  532. // VECTOREC
  533.  
  534.   if (vec1.CanMapTo(AFF_POINT)) {
  535.     ret = vec1.MapTo(AFF_POINT);
  536.     cout << ret;
  537.   } else {
  538.     cout << "Cannot Map\n";
  539.   } 
  540.   if (vec2.CanMapTo(AFF_POINT)) {
  541.     ret = vec2.MapTo(AFF_POINT);
  542.     cout << ret;
  543.   } else {
  544.     cout << "Cannot Map\n";
  545.   } 
  546.   if (vec1.CanMapTo(AFF_VECTOR)) { 
  547.     ret = vec1.MapTo(AFF_VECTOR);
  548.     cout << ret;
  549.   } else {
  550.     cout << "Cannot Map\n";
  551.   } 
  552.   if (vec2.CanMapTo(AFF_VECTOR)) { 
  553.     ret = vec2.MapTo(AFF_VECTOR);
  554.     cout << ret;
  555.   } else {
  556.     cout << "Cannot Map\n";
  557.   } 
  558.   if (vec1.CanMapTo(AFF_VEC_EC)) {
  559.     ret = vec1.MapTo(AFF_VEC_EC);
  560.     cout << ret;
  561.   } else {
  562.     cout << "Cannot Map\n";
  563.   } 
  564.   if (vec2.CanMapTo(AFF_VEC_EC)) {
  565.     ret = vec2.MapTo(AFF_VEC_EC);
  566.     cout << ret;
  567.   } else {
  568.     cout << "Cannot Map\n";
  569.   } 
  570.   if (vec1.CanMapTo(VECTOR)) {
  571.     ret = vec1.MapTo(VECTOR);
  572.     cout << ret;
  573.   } else {
  574.     cout << "Cannot Map\n";
  575.   } 
  576.   if (vec1.CanMapTo(VEC_EC)) {
  577.     ret = vec1.MapTo(VEC_EC);
  578.     cout << ret;
  579.   } else {
  580.     cout << "Cannot Map\n";
  581.   } 
  582.   if (vec1.CanMapTo(PROJ_POINT)) {
  583.     ret = vec1.MapTo(PROJ_POINT);
  584.     cout << ret;
  585.   } else {
  586.     cout << "Cannot Map\n";
  587.   }
  588.   if (vec2.CanMapTo(PROJ_POINT)) {
  589.     ret = vec2.MapTo(PROJ_POINT);
  590.     cout << ret;
  591.   } else {
  592.     cout << "Cannot Map\n";
  593.   }
  594.  
  595. // PROJECTIVE_POINT
  596.  
  597.   if (pp1.CanMapTo(AFF_POINT)) {
  598.     ret = pp1.MapTo(AFF_POINT);
  599.     cout << ret;
  600.   } else {
  601.     cout << "Cannot Map\n";
  602.   } 
  603.   if (pp2.CanMapTo(AFF_POINT)) {
  604.     ret = pp2.MapTo(AFF_POINT);
  605.     cout << ret;
  606.   } else {
  607.     cout << "Cannot Map\n";
  608.   } 
  609.   if (pp1.CanMapTo(AFF_VECTOR)) { 
  610.     ret = pp1.MapTo(AFF_VECTOR);
  611.     cout << ret;
  612.   } else {
  613.     cout << "Cannot Map\n";
  614.   } 
  615.   if (pp2.CanMapTo(AFF_VECTOR)) { 
  616.     ret = pp2.MapTo(AFF_VECTOR);
  617.     cout << ret;
  618.   } else {
  619.     cout << "Cannot Map\n";
  620.   } 
  621.   if (pp1.CanMapTo(AFF_VEC_EC)) {
  622.     ret = pp1.MapTo(AFF_VEC_EC);
  623.     cout << ret;
  624.   } else {
  625.     cout << "Cannot Map\n";
  626.   } 
  627.   if (pp2.CanMapTo(AFF_VEC_EC)) {
  628.     ret = pp2.MapTo(AFF_VEC_EC);
  629.     cout << ret;
  630.   } else {
  631.     cout << "Cannot Map\n";
  632.   } 
  633.   if (pp1.CanMapTo(VECTOR)) {
  634.     ret = pp1.MapTo(VECTOR);
  635.     cout << ret;
  636.   } else {
  637.     cout << "Cannot Map\n";
  638.   } 
  639.   if (pp2.CanMapTo(VECTOR)) {
  640.     ret = pp2.MapTo(VECTOR);
  641.     cout << ret;
  642.   } else {
  643.     cout << "Cannot Map\n";
  644.   } 
  645.   if (pp1.CanMapTo(VEC_EC)) {
  646.     ret = pp1.MapTo(VEC_EC);
  647.     cout << ret;
  648.   } else {
  649.     cout << "Cannot Map\n";
  650.   } 
  651.   if (pp1.CanMapTo(PROJ_POINT)) {
  652.     ret = pp1.MapTo(PROJ_POINT);
  653.     cout << ret;
  654.   } else {
  655.     cout << "Cannot Map\n";
  656.   } 
  657. }
  658.  
  659. // ***********************************************************************
  660. // Cross ratio calculations:
  661.  
  662. void test7(void)
  663. {
  664.   cout << "ENTERING TEST7\n";
  665.   VSpace v("Test vector space", 3, TRUE);
  666.   ASpace a("Test affine space", 2, TRUE);
  667.   PSpace p("Test projective space", v, a);
  668.  
  669. // Build four collinear points, map to various objects:
  670.  
  671.   Frame fra = a.StdBasis();
  672.   APoint a1(fra, ScalarList(0.0, 2.0, 1.0));
  673.   APoint a2(fra, ScalarList(0.0, 3.0, 1.0));
  674.   APoint a3 = (.5 * a1) + (.5 * a2);
  675.   APoint a4 = (.75 * a1) + (.25 * a2);
  676.  
  677.   Vector v1 = a1;
  678.   Vector v2 = a2;
  679.   Vector v3 = a3;
  680.   Vector v4 = a4;
  681.  
  682.   PPoint p1 = a1;
  683.   PPoint p2 = a2;
  684.   PPoint p3 = a3;
  685.   PPoint p4 = a4;
  686.  
  687.   GeOb ret;
  688.  
  689.   AugScalar augi(INFINITY);
  690.   AugScalar aug0(0.0);
  691.   AugScalar aug1(1.0);
  692.   AugScalar aug2(2.0);
  693.  
  694.   GeObList lst1(a1, v2, p3);
  695.   ret = CrossRatio(augi, lst1);
  696.   cout << ret;
  697.   ret = CrossRatio(aug0, lst1);
  698.   cout << ret;
  699.   ret = CrossRatio(aug1, lst1);
  700.   cout << ret;
  701.   ret = CrossRatio(aug2, lst1);
  702.   cout << ret;
  703.  
  704.   GeObList lst2(a1, v2, p3, ret);
  705.   AugScalar val = CrossRatioCalc(lst2);
  706.   cout << val;
  707.   lst2 = GeObList(a1, a2, a3, a1);
  708.   val = CrossRatioCalc(lst2);
  709.   cout << val;
  710.   lst2 = GeObList(a1, a2, a3, a2);
  711.   val = CrossRatioCalc(lst2);
  712.   cout << val;
  713.   lst2 = GeObList(a1, a2, a3, a3);
  714.   val = CrossRatioCalc(lst2);
  715.   cout << val;
  716.   lst2 = GeObList(a3, a3, a2, a1);
  717.   val = CrossRatioCalc(lst2);
  718.   cout << val;
  719. }
  720.  
  721. // ***********************************************************************
  722.